home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / PIL / PsdImagePlugin.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  6KB  |  223 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __version__ = '0.4'
  5. import string
  6. import Image
  7. import ImageFile
  8. import ImagePalette
  9. MODES = {
  10.     (0, 1): ('1', 1),
  11.     (0, 8): ('L', 1),
  12.     (1, 8): ('L', 1),
  13.     (2, 8): ('P', 1),
  14.     (3, 8): ('RGB', 3),
  15.     (4, 8): ('CMYK', 4),
  16.     (7, 8): ('L', 1),
  17.     (8, 8): ('L', 1),
  18.     (9, 8): ('LAB', 3) }
  19.  
  20. def i16(c):
  21.     return ord(c[1]) + (ord(c[0]) << 8)
  22.  
  23.  
  24. def i32(c):
  25.     return ord(c[3]) + (ord(c[2]) << 8) + (ord(c[1]) << 16) + (ord(c[0]) << 24)
  26.  
  27.  
  28. def _accept(prefix):
  29.     return prefix[:4] == '8BPS'
  30.  
  31.  
  32. class PsdImageFile(ImageFile.ImageFile):
  33.     format = 'PSD'
  34.     format_description = 'Adobe Photoshop'
  35.     
  36.     def _open(self):
  37.         read = self.fp.read
  38.         s = read(26)
  39.         if s[:4] != '8BPS' or i16(s[4:]) != 1:
  40.             raise SyntaxError, 'not a PSD file'
  41.         
  42.         psd_bits = i16(s[22:])
  43.         psd_channels = i16(s[12:])
  44.         psd_mode = i16(s[24:])
  45.         (mode, channels) = MODES[(psd_mode, psd_bits)]
  46.         if channels > psd_channels:
  47.             raise IOError, 'not enough channels'
  48.         
  49.         self.mode = mode
  50.         self.size = (i32(s[18:]), i32(s[14:]))
  51.         size = i32(read(4))
  52.         if size:
  53.             data = read(size)
  54.             if mode == 'P' and size == 768:
  55.                 self.palette = ImagePalette.raw('RGB;L', data)
  56.             
  57.         
  58.         self.resources = []
  59.         size = i32(read(4))
  60.         if size:
  61.             end = self.fp.tell() + size
  62.             while self.fp.tell() < end:
  63.                 signature = read(4)
  64.                 id = i16(read(2))
  65.                 name = read(ord(read(1)))
  66.                 if not len(name) & 1:
  67.                     read(1)
  68.                 
  69.                 data = read(i32(read(4)))
  70.                 if len(data) & 1:
  71.                     read(1)
  72.                 
  73.                 self.resources.append((id, name, data))
  74.         
  75.         self.layers = []
  76.         size = i32(read(4))
  77.         if size:
  78.             end = self.fp.tell() + size
  79.             size = i32(read(4))
  80.             if size:
  81.                 self.layers = _layerinfo(self.fp)
  82.             
  83.             self.fp.seek(end)
  84.         
  85.         self.tile = _maketile(self.fp, mode, (0, 0) + self.size, channels)
  86.         self._fp = self.fp
  87.         self.frame = 0
  88.  
  89.     
  90.     def seek(self, layer):
  91.         if layer == self.frame:
  92.             return None
  93.         
  94.         
  95.         try:
  96.             if layer <= 0:
  97.                 raise IndexError
  98.             
  99.             (name, mode, bbox, tile) = self.layers[layer - 1]
  100.             self.mode = mode
  101.             self.tile = tile
  102.             self.frame = layer
  103.             self.fp = self._fp
  104.             return (name, bbox)
  105.         except IndexError:
  106.             raise EOFError, 'no such layer'
  107.  
  108.  
  109.     
  110.     def tell(self):
  111.         return self.frame
  112.  
  113.     
  114.     def load_prepare(self):
  115.         if not (self.im) and self.im.mode != self.mode or self.im.size != self.size:
  116.             self.im = Image.core.fill(self.mode, self.size, 0)
  117.         
  118.         if self.mode == 'P':
  119.             Image.Image.load(self)
  120.         
  121.  
  122.  
  123.  
  124. def _layerinfo(file):
  125.     layers = []
  126.     read = file.read
  127.     for i in range(abs(i16(read(2)))):
  128.         y0 = i32(read(4))
  129.         x0 = i32(read(4))
  130.         y1 = i32(read(4))
  131.         x1 = i32(read(4))
  132.         info = []
  133.         mode = []
  134.         for i in range(i16(read(2))):
  135.             type = i16(read(2))
  136.             if type == 65535:
  137.                 m = 'A'
  138.             else:
  139.                 m = 'RGB'[type]
  140.             mode.append(m)
  141.             size = i32(read(4))
  142.             info.append((m, size))
  143.         
  144.         mode.sort()
  145.         if mode == [
  146.             'R']:
  147.             mode = 'L'
  148.         elif mode == [
  149.             'B',
  150.             'G',
  151.             'R']:
  152.             mode = 'RGB'
  153.         elif mode == [
  154.             'A',
  155.             'B',
  156.             'G',
  157.             'R']:
  158.             mode = 'RGBA'
  159.         else:
  160.             mode = None
  161.         filler = read(12)
  162.         name = None
  163.         file.seek(i32(read(4)), 1)
  164.         layers.append((name, mode, (x0, y0, x1, y1)))
  165.     
  166.     i = 0
  167.     for name, mode, bbox in layers:
  168.         tile = []
  169.         for m in mode:
  170.             t = _maketile(file, m, bbox, 1)
  171.             if t:
  172.                 tile.extend(t)
  173.                 continue
  174.         
  175.         layers[i] = (name, mode, bbox, tile)
  176.         i = i + 1
  177.     
  178.     return layers
  179.  
  180.  
  181. def _maketile(file, mode, bbox, channels):
  182.     tile = None
  183.     read = file.read
  184.     compression = i16(read(2))
  185.     xsize = bbox[2] - bbox[0]
  186.     ysize = bbox[3] - bbox[1]
  187.     offset = file.tell()
  188.     if compression == 0:
  189.         tile = []
  190.         for channel in range(channels):
  191.             layer = mode[channel]
  192.             if mode == 'CMYK':
  193.                 layer = layer + ';I'
  194.             
  195.             tile.append(('raw', bbox, offset, layer))
  196.             offset = offset + xsize * ysize
  197.         
  198.     elif compression == 1:
  199.         i = 0
  200.         tile = []
  201.         bytecount = read(channels * ysize * 2)
  202.         offset = file.tell()
  203.         for channel in range(channels):
  204.             layer = mode[channel]
  205.             if mode == 'CMYK':
  206.                 layer = layer + ';I'
  207.             
  208.             tile.append(('packbits', bbox, offset, layer))
  209.             for y in range(ysize):
  210.                 offset = offset + i16(bytecount[i:i + 2])
  211.                 i = i + 2
  212.             
  213.         
  214.     
  215.     file.seek(offset)
  216.     if offset & 1:
  217.         read(1)
  218.     
  219.     return tile
  220.  
  221. Image.register_open('PSD', PsdImageFile, _accept)
  222. Image.register_extension('PSD', '.psd')
  223.